home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Hunks.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  16KB  |  700 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysHunks.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void HunkStruct ( void );
  12.    *    void PrintHunkStruct ( char *file );
  13.    *
  14.    *      --- Lokale  Routinen ---
  15.    *
  16.    *    static int jumpinfile ( ULONG d );
  17.    *    static int readlong ( ULONG *d );
  18.    *    static int readtext ( char *d , long count );
  19.    *    static long currentpos ( void );
  20.    *    static struct hunkentry *makehunkentry ( struct hunkentry *last , char *name );
  21.    *    static void MakeHunkList ( char *file );
  22.    *    static void ScanHunks ( char *filename );
  23.    *
  24.    * Bemerkungen:
  25.    *      Ermittlung der Hunkstruktur einer ausführbaren oder ladbaren Datei.
  26.    *
  27.    * Erstellungsdatum:
  28.    *      07-Jul-93     Rolf Böhme
  29.    *
  30.    * Änderungen:
  31.    *      07-Jul-93     Rolf Böhme        Erstellung
  32.    *
  33.    ***************************************************************************
  34.  */
  35.  
  36. #include "RSys.h"
  37. #include "protos.h"
  38.  
  39.  
  40. static REMEMBER *hekey = NULL;
  41.  
  42.  
  43. static RSYS_hunkentry *loop, *firstde;
  44. static LIST Tree;
  45.  
  46. static enum ext_types1
  47.   {
  48.     ext_def = 1,
  49.     ext_abs,
  50.     ext_res
  51.   };
  52.  
  53. static char *ext_names1[] =
  54. {
  55.   "dummy   ",
  56.   "ext_def ",
  57.   "ext_abs ",
  58.   "ext_res "
  59. };
  60.  
  61. static enum ext_types2
  62.   {
  63.     ext_ref32 = 129,
  64.     ext_common,
  65.     ext_ref16,
  66.     ext_ref8,
  67.     ext_dref32,
  68.     ext_dref16,
  69.     ext_dref8
  70.   };
  71.  
  72. static char *ext_names2[] =
  73. {
  74.   "ext_ref32  ",
  75.   "ext_common ",
  76.   "ext_ref16  ",
  77.   "ext_ref8   ",
  78.   "ext_dref32 ",
  79.   "ext_dref16 ",
  80.   "ext_dref8  "
  81. };
  82.  
  83. static enum hunktypes
  84.   {
  85.     hunk_unit = 0x3e7,
  86.     hunk_name,            /* 0x3e8 */
  87.     hunk_code,            /* 0x3e9 */
  88.     hunk_data,            /* 0x3ea */
  89.     hunk_bss,            /* 0x3eb */
  90.     hunk_reloc32,        /* 0x3ec */
  91.     hunk_reloc16,        /* 0x3ed */
  92.     hunk_reloc8,        /* 0x3ee */
  93.     hunk_ext,            /* 0x3ef */
  94.     hunk_symbol,        /* 0x3f0 */
  95.     hunk_debug,            /* 0x3f1 */
  96.     hunk_end,            /* 0x3f2 */
  97.     hunk_header,        /* 0x3f3 */
  98.     dummy,            /* 0x3f4 */
  99.     hunk_overlay,        /* 0x3f5 */
  100.     hunk_break,            /* 0x3f6 */
  101.     dummy1,            /* 0x3f7 */
  102.     dummy2,            /* 0x3f8 */
  103.     dummy3,            /* 0x3f9 */
  104.     hunk_lib,            /* 0x3fa */
  105.     hunk_libindex        /* 0x3fb */
  106.   };
  107.  
  108. char *names[] =
  109. {
  110.   "hunk_unit",
  111.   "hunk_name",
  112.   "  hunk_code",
  113.   "  hunk_data",
  114.   "  hunk_bss",
  115.   "    hunk_reloc32",
  116.   "    hunk_reloc16",
  117.   "    hunk_reloc8 ",
  118.   "    hunk_ext",
  119.   "    hunk_symbol",
  120.   "  hunk_debug",
  121.   "hunk_end",
  122.   "hunk_header",
  123.   "dummy",
  124.   "hunk_overlay",
  125.   "hunk_break  ",
  126.   "dummy",
  127.   "dummy",
  128.   "dummy",
  129.   "lib_hunk",
  130.   "lib_index"
  131. };
  132.  
  133. static BPTR file;
  134.  
  135.  /*
  136.   * make_hunkentry() erzeugt einen Listeneintrag aus einem Hunk
  137.   * einer ausführbaren Datei
  138.   */
  139. static RSYS_hunkentry *
  140. make_hunkentry (RSYS_hunkentry * last, char *name)
  141. {
  142.   DPOS;
  143.  
  144.   if ((last = (RSYS_hunkentry *) AllocRemember (ERKEY, ESIZEDE, MEMF_CLEAR | MEMF_ANY)) &&
  145.       (last->name = (char *) AllocRemember (ERKEY, strlen (name) + 1, MEMF_CLEAR | MEMF_ANY)))
  146.     {
  147.       strcpy (last->name, name);
  148.  
  149.       last->next = NULL;
  150.       last->denode.ln_Name = last->name;
  151.       last->denode.ln_Type = 0;
  152.  
  153.       InitListView (TreeWnd, TreeGadgets[GD_TreeLV - GD_TreeLV], NULL, UNSETLVPOS);
  154.  
  155.       AddTail (&Tree, &last->denode);
  156.  
  157.       InitListView (TreeWnd, TreeGadgets[GD_TreeLV - GD_TreeLV], &Tree, decnt);
  158.  
  159.       decnt++;
  160.  
  161.       return last->next;
  162.     }
  163.   else
  164.     ErrorHandle ("Hunk memory", MEMORY_ERR, ALLOC_FAIL, KILL);
  165.  
  166.   return NULL;
  167. }
  168.  
  169.  /*
  170.   * jumpinfile() setzt den Dateizeiger um eine Anzahl ULONG's
  171.   * weiter vor
  172.   */
  173. static int
  174. jumpinfile (ULONG d)
  175. {
  176.   int serr;
  177.  
  178.   serr = Seek (file, d * sizeof (ULONG), OFFSET_CURRENT);
  179.   if (serr < 0)
  180.     return FALSE;
  181.  
  182.   return TRUE;
  183. }
  184.  
  185.  /*
  186.   * readlong() liest ein ULONG aus einer Datei aus
  187.   */
  188. static int
  189. readlong (ULONG * d)
  190. {
  191.   return Read (file, d, sizeof (ULONG));
  192. }
  193.  
  194.  /*
  195.   * readtext() liest einen Text definierter Länge aus
  196.   * einer Datei aus
  197.   */
  198. static int
  199. readtext (char *d, long count)
  200. {
  201.   ULONG readdata[MAXSTRLEN];
  202.   int ret = 0, i, len = 0;
  203.   union
  204.     {
  205.       ULONG ul;
  206.       unsigned char ut[4];
  207.     }
  208.   cv;
  209.  
  210.   if (count == 0)
  211.     {
  212.       strcpy (d, field[NO_FIELD]);
  213.       return ret;
  214.     }
  215.  
  216.   ret = Read (file, readdata, count * sizeof (ULONG));
  217.  
  218.   d[0] = STRINGEND;
  219.   cv.ul = 0L;
  220.   cv.ul = readdata[0];
  221.   strncpy (d, (char *) cv.ut, 4);
  222.   len += 4;
  223.   d[len] = STRINGEND;
  224.  
  225.   for (i = 1; i < count; i++)
  226.     {
  227.       cv.ul = 0L;
  228.       cv.ul = readdata[i];
  229.       strncat (d, (char *) cv.ut, 4);
  230.       len += 4;
  231.       d[len] = STRINGEND;
  232.     }
  233.  
  234.   return ret;
  235. }
  236.  
  237.  /*
  238.   * currentpos() ermittelt die aktuelle Position des Dateizeigers
  239.   */
  240. static long
  241. currentpos (void)
  242. {
  243.   return Seek (file, 0L, OFFSET_CURRENT) - (LONG) sizeof (ULONG);    /*GMD */
  244. }
  245.  
  246.  /*
  247.   * ScanHunks() ermittelt alle Hunks eines ausführbaren Files und
  248.   * trägt diese in eine interne Liste ein
  249.   */
  250. static void
  251. ScanHunks (char *filename)
  252. {
  253.   ULONG data, data2, data3, type, typeofmem, type_of_hunk, lasthunk = hunk_name;
  254.   char datatext[120];
  255.   int error, i, z;
  256.   char buffer[MAXFULLNAME], blanks[10] = "  ", *seek_err = "Seek() error!",
  257.    *memtype[3] =
  258.   {"MEMF_CHIP", "MEMF_FAST"};
  259.   int ext_type, failure = 0;
  260.  
  261.   DPOS;
  262.  
  263.   sprintf (buffer, "File name : %s", filename);
  264.   loop = make_hunkentry (loop, buffer);
  265.  
  266.   sprintf (buffer, "File size : %ld", SizeOfFile (filename));
  267.   loop = make_hunkentry (loop, buffer);
  268.  
  269.   if (file = Open ((UBYTE *) filename, MODE_OLDFILE))
  270.     {
  271.       error = readlong (&data);
  272.  
  273.       while ((error > 0) && NOT (ClickedCloseGadget ()))
  274.     {
  275.       type = data - hunk_unit;
  276.       type_of_hunk = ((data << 8) >> 8);
  277.  
  278.       if ((type_of_hunk >= hunk_unit) && (type_of_hunk <= hunk_libindex) &&
  279.           (type_of_hunk != hunk_end) && (type_of_hunk != hunk_break))
  280.         {
  281.           loop = make_hunkentry (loop, (char *) field[BLANK_FIELD]);
  282.           sprintf (buffer, "%s (o: \$%lX,\#%ld t: \$%lX,\#%ld)",
  283.                names[type], currentpos (),
  284.                currentpos (), data, data);
  285.           loop = make_hunkentry (loop, buffer);
  286.         }
  287.  
  288.       switch (type_of_hunk)
  289.         {
  290.         case hunk_unit:
  291.         case hunk_name:
  292.           error = readlong (&data);
  293.  
  294.           if ((error > 0) && data)
  295.         {
  296.           error = readtext (datatext, data);
  297.           sprintf (buffer, "  Name: %s", (char *) datatext);
  298.         }
  299.           else
  300.         strcpy (buffer, "  Name: -");
  301.  
  302.           loop = make_hunkentry (loop, buffer);
  303.           break;
  304.  
  305.         case hunk_code:
  306.         case hunk_bss:
  307.         case hunk_data:
  308.           typeofmem = ((data & (1L << 30)) ? 0 : 1);
  309.  
  310.           error = readlong (&data);
  311.  
  312.           sprintf (buffer, "    Size: \$%lX, \#%ld (%s)", data * 4, data * 4, memtype[typeofmem]);
  313.           loop = make_hunkentry (loop, buffer);
  314.  
  315.           if (type_of_hunk != hunk_bss)
  316.         if (NOT (jumpinfile (data)))
  317.           loop = make_hunkentry (loop, seek_err);
  318.  
  319.           break;
  320.  
  321.         case hunk_reloc32:
  322.         case hunk_reloc16:
  323.         case hunk_reloc8:
  324.           error = readlong (&data);
  325.           while ((error > 0) && data != 0L)
  326.         {
  327.           data2 = data;
  328.           error = readlong (&data3);
  329.           sprintf (buffer, "     \#%-3ld offsets in Hunk \#%-3ld", data, data3);
  330.           loop = make_hunkentry (loop, buffer);
  331.  
  332.           if (NOT (jumpinfile (data2)))
  333.             {
  334.               loop = make_hunkentry (loop, seek_err);
  335.               break;
  336.             }
  337.  
  338.           error = readlong (&data);
  339.         }
  340.  
  341.           break;
  342.  
  343.         case hunk_ext:
  344.           error = readlong (&data);
  345.           z = 0;
  346.  
  347.           while (data && (error > 0))
  348.         {
  349.           ext_type = (int) (data >> 24);
  350.           data = (data << 8) >> 8;
  351.  
  352.           switch (ext_type)
  353.             {
  354.             case ext_def:
  355.             case ext_abs:
  356.             case ext_res:
  357.               error = readtext (datatext, data);
  358.               error = readlong (&data2);
  359.               sprintf (buffer, "      %s: %-22s val: %ld",
  360.                ext_names1[ext_type - ext_def + 1], datatext, data2);
  361.  
  362.               loop = make_hunkentry (loop, buffer);
  363.               break;
  364.  
  365.             case ext_ref32:
  366.             case ext_dref32:
  367.               error = readtext (datatext, data);
  368.               error = readlong (&data2);
  369.               sprintf (buffer, "      %s: %-22s refs: %ld",
  370.              ext_names2[ext_type - ext_ref32], datatext, data2);
  371.  
  372.               loop = make_hunkentry (loop, buffer);
  373.  
  374.               if (NOT (jumpinfile (data2)))
  375.             loop = make_hunkentry (loop, seek_err);
  376.               break;
  377.  
  378.             case ext_common:
  379.               error = readlong (&data);
  380.               error = readlong (&data2);
  381.               sprintf (buffer, "      %s (size): %ld  refs: %ld",
  382.                  ext_names2[ext_type - ext_ref32], data, data2);
  383.               loop = make_hunkentry (loop, buffer);
  384.  
  385.               if (NOT (jumpinfile (data2)))
  386.             loop = make_hunkentry (loop, seek_err);
  387.  
  388.               break;
  389.  
  390.             case ext_ref16:
  391.             case ext_ref8:
  392.             case ext_dref16:
  393.             case ext_dref8:
  394.               error = readtext (datatext, data);
  395.               error = readlong (&data2);
  396.               sprintf (buffer, "      %s: %-22s refs: %ld",
  397.              ext_names2[ext_type - ext_ref32], datatext, data2);
  398.  
  399.               loop = make_hunkentry (loop, buffer);
  400.  
  401.               if (NOT (jumpinfile (data2)))
  402.             loop = make_hunkentry (loop, seek_err);
  403.               break;
  404.  
  405.             default:
  406.               loop = make_hunkentry (loop, "Unknown external reference!");
  407.               break;
  408.             }
  409.  
  410.           z++;
  411.           error = readlong (&data);
  412.         }
  413.  
  414.           sprintf (buffer, "      External refs: %ld", z);
  415.           loop = make_hunkentry (loop, buffer);
  416.           break;
  417.  
  418.         case hunk_symbol:
  419.           error = readlong (&data);
  420.           z = 0;
  421.           while (data && (error > 0))
  422.         {
  423.           data = (data << 8) >> 8;
  424.           error = readtext (datatext, data);
  425.           error = readlong (&data);
  426.           sprintf (buffer, "      Symbol: %-22s  val: %ld",
  427.                datatext, data);
  428.           loop = make_hunkentry (loop, buffer);
  429.  
  430.           error = readlong (&data);
  431.           z++;
  432.         }
  433.  
  434.           sprintf (buffer, "      External symbols: %ld", z);
  435.           loop = make_hunkentry (loop, buffer);
  436.           break;
  437.  
  438.         case hunk_debug:
  439.           error = readlong (&data);
  440.           sprintf (buffer, "  \$%lX, \#%ld", data * 4, data * 4);
  441.           loop = make_hunkentry (loop, buffer);
  442.  
  443.           if (NOT (jumpinfile (data)))
  444.         loop = make_hunkentry (loop, seek_err);
  445.  
  446.           break;
  447.  
  448.         case hunk_end:
  449.           if (lasthunk >= hunk_code && lasthunk <= hunk_debug)
  450.         strcpy (blanks, "  ");
  451.           else
  452.         strcpy (blanks, "      ");
  453.  
  454.           sprintf (buffer, "%s%s (o: \$%lX,\#%ld t: \$%lX,\#%ld)",
  455.           blanks, names[type], currentpos (), currentpos (), data, data);
  456.  
  457.           loop = make_hunkentry (loop, buffer);
  458.           break;
  459.  
  460.         case hunk_header:
  461.           error = readlong (&data);
  462.  
  463.           while ((error > 0) && data != 0L)
  464.         error = readlong (&data);
  465.  
  466.           error = readlong (&data);
  467.           sprintf (buffer, "  Count hunks : \#%ld", data);
  468.           loop = make_hunkentry (loop, buffer);
  469.  
  470.           error = readlong (&data2);
  471.           sprintf (buffer, "  First hunk  : \#%ld", data2);
  472.           loop = make_hunkentry (loop, buffer);
  473.  
  474.           error = readlong (&data3);
  475.           sprintf (buffer, "  Last hunk   : \#%ld", data3);
  476.           loop = make_hunkentry (loop, buffer);
  477.  
  478.           for (i = data2; error && i <= data3; i++)
  479.         {
  480.           error = readlong (&data);
  481.           if (error > 0)
  482.             {
  483.               sprintf (buffer, "    Hunk \#%ld, Length \$%lX, \#%ld",
  484.                    i, data * 4, data * 4);
  485.               loop = make_hunkentry (loop, buffer);
  486.             }
  487.           else
  488.             {
  489.               sprintf (buffer, "    Hunk \#%ld, Length ??", i);
  490.               loop = make_hunkentry (loop, buffer);
  491.             }
  492.         }
  493.  
  494.           break;
  495.  
  496.         case hunk_overlay:
  497.           error = readlong (&data);
  498.           sprintf (buffer, "  Table size: \$%lX, \#%ld", data, data);
  499.           loop = make_hunkentry (loop, buffer);
  500.  
  501.           if (NOT (jumpinfile (data)))
  502.         loop = make_hunkentry (loop, seek_err);
  503.  
  504.           break;
  505.  
  506.         case hunk_break:
  507.           loop = make_hunkentry (loop, (char *) field[BLANK_FIELD]);
  508.           sprintf (buffer, "%s (o: \$%lX,\#%ld t: \$%lX,\#%ld)",
  509.              names[type], currentpos (), currentpos (), data, data);
  510.           loop = make_hunkentry (loop, buffer);
  511.  
  512.           break;
  513.  
  514.         case hunk_lib:
  515.         case hunk_libindex:
  516.           error = readlong (&data);
  517.           sprintf (buffer, "\$%lX, \#%ld", data * 4, data * 4);
  518.           loop = make_hunkentry (loop, buffer);
  519.  
  520.           if (NOT (jumpinfile (data)))
  521.         loop = make_hunkentry (loop, seek_err);
  522.  
  523.           break;
  524.  
  525.         default:
  526.           loop = make_hunkentry (loop, (char *) field[BLANK_FIELD]);
  527.           sprintf (buffer, "%s: \#%ld (\$%lX)", "Unknown hunk type position",
  528.                currentpos (), currentpos ());
  529.           loop = make_hunkentry (loop, buffer);
  530.           failure++;
  531.  
  532.           if (failure >= 5)
  533.         Seek (file, 0L, OFFSET_END);
  534.           break;
  535.         }
  536.  
  537.       lasthunk = type_of_hunk;
  538.  
  539.       error = readlong (&data);
  540.     }
  541.  
  542.       Close (file);
  543.     }
  544.  
  545.   return;
  546. }
  547.  
  548.  /*
  549.   * MakeHunkList() erzeugt aus einem ausführbaren File eine
  550.   * Liste aus den Hunks, aus denen das Executable besteht. Zuvor
  551.   * werden die Gadgets deaktiviert
  552.   */
  553. static void
  554. MakeHunkList (char *file)
  555. {
  556.   loop = firstde;
  557.  
  558.   if (SysWnd)
  559.     PrintInfo ("Scanning Hunks", SPEAK, 0);
  560.  
  561.   SetWindowTitles (TreeWnd, (UBYTE *) "<- Cancel reading Hunks...", NOSCREENTITLECHANGE);
  562.   EnableGadget (TreeWnd, TreeGadgets[GD_SaveGad - GD_TreeLV], FALSE);
  563.   EnableGadget (TreeWnd, TreeGadgets[GD_KindCY - GD_TreeLV], FALSE);
  564.  
  565.   ScanHunks (file);
  566.  
  567.   SetWindowTitles (TreeWnd, TreeWdt1, NOSCREENTITLECHANGE);
  568.   EnableGadget (TreeWnd, TreeGadgets[GD_SaveGad - GD_TreeLV], TRUE);
  569.   EnableGadget (TreeWnd, TreeGadgets[GD_KindCY - GD_TreeLV], TRUE);
  570.  
  571.   return;
  572. }
  573.  
  574.  /*
  575.   * PrintHunkStruct() bietet eine kleine Benutzeroberfläche an
  576.   * und ermittelt die Hunks eines Executables. Diese werden dann
  577.   * in einem ListView angezeigt
  578.   */
  579. void
  580. PrintHunkStruct (char *file)
  581. {
  582.   INTUIMESSAGE *message;
  583.   ULONG class, code;
  584.   APTR object;
  585.   int id;
  586.  
  587.   DPOS;
  588.  
  589.   HandleHelp (MN_HunkStruct);
  590.  
  591.   Flags.quit_hunk = 0;
  592.  
  593.   NewList (&Tree);
  594.  
  595.   if (NOT (OpenTreeWindow (NULL, TRUE)))
  596.     {
  597.       PrintInfo ("Scanning Hunks", SPEAK, 0);
  598.  
  599.       LockMainWindow (WIN_LOCK);
  600.  
  601.       decnt = 0;
  602.  
  603.       if (file)
  604.     {
  605.       InitListView (TreeWnd, TreeGadgets[GD_TreeLV - GD_TreeLV], NULL, UNSETLVPOS);
  606.  
  607.       breakit = FALSE;
  608.  
  609.       MakeHunkList (file);
  610.     }
  611.  
  612.       do
  613.     {
  614.       Wait (1L << TreeWnd->UserPort->mp_SigBit);
  615.  
  616.       while ((message = (INTUIMESSAGE *) GT_GetIMsg (TreeWnd->UserPort)) != NULL)
  617.         {
  618.           class = message->Class;
  619.           code = message->Code;
  620.           object = message->IAddress;
  621.  
  622.           GT_ReplyIMsg (message);
  623.  
  624.           switch (class)
  625.         {
  626.         case IDCMP_CLOSEWINDOW:
  627.           Flags.quit_hunk = 1;
  628.           break;
  629.  
  630.         case IDCMP_GADGETUP:
  631.           id = ((GADGET *) object)->GadgetID;
  632.  
  633.           HandleHelp ((enum RSysNumbers) id);
  634.  
  635.           switch (id)
  636.             {
  637.             case GD_SaveGad:
  638.               if (GetFile (TreeWnd, "RAM:", "RSys-Hunk.DAT", "#?.dat",
  639.                  "Select File for saving hunklist", "Save"))
  640.             SaveList (TreeWnd, (char *) _fullpath,
  641.                   (char *) "RSys-Hunk.DAT", &Tree, FALSE);
  642.               break;
  643.  
  644.             case GD_KindCY:
  645.               InitListView (TreeWnd, TreeGadgets[GD_TreeLV - GD_TreeLV], NULL, UNSETLVPOS);
  646.  
  647.               NewList (&Tree);
  648.               FreeRemember (ERKEY, TRUE);
  649.  
  650.               decnt = 0;
  651.               breakit = FALSE;
  652.  
  653.               if (GetFile (TreeWnd, "C:", "unknown", "#?", "Select File for Hunk list", "Show"))
  654.             MakeHunkList ((char *) _fullpath);
  655.  
  656.               break;
  657.             }
  658.           break;
  659.  
  660.         case IDCMP_VANILLAKEY:
  661.           if ((char) code == ESC)
  662.             Flags.quit_hunk = 1;
  663.           break;
  664.         }
  665.         }
  666.     }
  667.       while (NOT (Flags.quit_hunk));
  668.  
  669.       InitListView (TreeWnd, TreeGadgets[GD_TreeLV - GD_TreeLV], NULL, UNSETLVPOS);
  670.  
  671.       NewList (&Tree);
  672.       FreeRemember (ERKEY, TRUE);
  673.  
  674.       CloseASysWindow (&TreeWnd, &TreeGList, NULL);
  675.  
  676.       LockMainWindow (WIN_UNLOCK);
  677.     }
  678.   else
  679.     ErrorHandle ((char *) TreeWdt1, WINDOW_ERR, OPEN_FAIL, NO_KILL);
  680.  
  681.   PrintStatistics ();
  682.  
  683.   return;
  684. }
  685.  
  686.  /*
  687.   * PrintHunkStruct() kann mit einem Parameter aufgerufen werden
  688.   * oder ohne. Kommt der Aufruf nicht vom RSysAppIcon, so wird kein
  689.   * Filename übergeben und der Aufruf wird von HunkStruct() aus
  690.   * getätigt
  691.   */
  692. void
  693. HunkStruct (void)
  694. {
  695.   DPOS;
  696.  
  697.   PrintHunkStruct (NULL);
  698.   return;
  699. }
  700.